#!/user/bin/env python3
# -*- coding:utf-8

__author__="Yang";
import re

#input and output
print ("hello World");
# 遇到逗号，在拼接字符串的时候自动添加空格
print ("heelo","World");
# name = input();
# print("Hello", name);
name="yhq";
print ("hello %s"%name);
first_name="xiao";
last_name="qiang";
print ("hellp %s%s"%(first_name,last_name))

# ==== 数据类型 ====
a=33;
print ("a的数据类型为%s,值为%s"%(type(a),a));
print (type(a)==int);
print (isinstance(a,int));
a=33.3
print ("a的数据类型%s,值为%s"%(type(a),a));
b = float(a);
print ("b的数据类型%s,值%s"%(type(b),b));
a="33";
print ("a的书记类型为%s,值为%s"%(type(a),a));
a=3>2;
print ("a的数据类型为%s,值为%s"%(type(a),a));
a=None;
print ("a的数据类型为%s,值为%s"%(type(a),a));
a=b"asd";
print ("a的数据类型为%s,值为%s"%(type(a),a));
a=["aaa","bbb"];
print ("a的数据类型为%s,值为%s"%(type(a),a));
a=("aaa","bbb");
print ("a的数据类型为%s,值为%s"%(type(a),a));

# ==== 运算符 ====
print ((100+22.2-5*2)/2);
#地板除，取整
print (5//2);
print (5%2);
#乘方
print (2 ** 3);
a = True and False;
print ("a的数据类型为%s,值为%s"%(type(a),a));
a = True or False;
print ("a的数据类型为%s,值为%s"%(type(a),a));
a = not False;
print ("a的数据类型为%s,值为%s"%(type(a),a));

# ==== ASCII转换 ====
print ("98-->%s;a-->%s"%(chr(98),ord('a')));

# ==== encode && decode ====
# 输出b'cdsa'，转化为bytes类型；
print ("cdsa".encode("ascii"));

#报错，ascii只定义了127个字符中文无法解析
#print ("中文".encode("ascii"));

#将bytes类型按照ascii解码；
print(b'cdsa'.decode("ascii"));
#输出中文，将bytes类型按照utf8解码;
print(b'\xe4\xb8\xad\xe6\x96\x87'.decode("utf-8"));

# ==== 前缀字符串 ====
# 后面字符串是以Unicode编码
print (u'中文');
# 后面字符串是普通字符串
print (r'dddd');
# 后面是bytes
print (b'qwerr');

# ==== len ====
# 对于str计算字符数
print (len("aaa"));
#对于str计算字符数
print (len("中文"));
#对于bytes计算字节数
print (len("aaa".encode("utf-8")));
#对于bytes计算字节数
print (len("中文".encode("utf-8")));

# ==== replace ====
a = "abcdefg";
print (a.replace("abcdefg","----"));
print (a);

# ==== find ====
# 字符串第一次出现下标，没有-1
print ("cdsacdas".find("a"));
# 字符串最后一次出现下标，没有-1
print ("cdsacdas".rfind("a"));

# ==== isspace ====
print (" ".isspace());

# ==== contain ====
temp = "全省累计报告新型冠状病毒肺炎确诊病例"
print (temp.__contains__("全省累计"));

# ==== 字符串格式化 ====
# 2d（不足两位左边补空 格）、02d（不足两位，左边补 0）
print ("%d---%2d----%02d"%(2,3,4));
# .2f（保留两位小数，四舍五 入）
print ("%f----%.2f"%(222.2,333.345));
# 格式化为十六进制
print ("%x"%333);
print("%s%%%s"%("3", "2"));
# 将2-10生成器，转化为字符
print (list("%s"% x for x in range(2,10)));
print ("hi{0},成体提高了{1:.1f}%".format("小明",1.234));
print("Hi {0}, 成绩提高了{1}%".format("小明", "%.1f"%1.234));
print("-".join(["a", "b", "c"]));

# ==== match & search ====
# 从头开始匹配
ma=re.match("c","abcda");
print (ma);
# 从 anywhere 匹配
se = re.search("c","adcda")
print (se);
# ==== 匹配字符串 ====
email_re = "^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$";
# 如果匹配成功，将返回一个Math对象，失败则返回None
if re.match(email_re,"yang@163.com"):
    print ("ok")
else:
    print ("err");

# ==== 切分字符串 ====
print ("a b c".split(" .  "));
print (re.split(r"\s+","a b c"));
print(re.split(r"[\s\,\;]+", "a,b;; c d"));

# ==== 分组 ====
# 分组提取电话号码
math = re.match(r"^(\d{3})-(\d{3,8})$", "010-12345");
print (math.groups());
print (math.group(0));
print (math.group(1));
print (math.group(2));

# 分组提起时间
math = re.match(r"^(0[0-9]|1[0-9]|2[0-3]|[0-9])\:" r"(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])\:" r"(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])$", "19:05:30");
print (math.groups());
# 分组提取数字
temp = "截至8月20日0时，全省累计报告新型冠状病毒肺炎确诊病例627例(其中境外输入86例），" \
           "累计治愈出院609例，死亡3例，目前在院隔离治疗15例，551人尚在接受医学观察。 ";
# 前后不添加 ^$，添加后强制起始和结为，如果解析的字符串有空格，则无法进行匹配
temp_re = r'截至8月20日0时，全省累计报告新型冠状病毒肺炎确诊病例(\d+)例\(其中境外输入(\d+)例\），' \
r'累计治愈出院(\d+)例，死亡(\d+)例，目前在院隔离治疗(\d+)例，(\d+)人尚在接受医学观察。';
ma = re.match(temp_re,temp);
print (ma.group(1));
se = re.search(temp_re,temp);
print (se.group(1))

# 贪婪匹配
print(re.match(r"^(\d+)(0*)$", "102300").groups());
print(re.match(r"^(\d+?)(0*)$", "102300").groups());

#Email 验证、找出用户名
email_re = r'^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$';
email_name_re = r'<?([^@|^>]*).*@.*';
print(re.match(email_re, "hyman@163.com"));
print(re.match(email_re, "bill.gates@microsoft.com"));
print(re.match(email_re, "y_cat-st@example.com"));
print(re.match(email_name_re, "<Tom Paris> tom@voyager.org").groups());
print(re.match(email_name_re, "tom@voyager.org").groups());

#list：有序的集合，中括号定义，元素类型可不一致，可以随时添加和删除其中的元素；
# ==== list ====
l = list(range(10));
l = ["csa",123,True,"cdsacda"];
# 从前取值，index从0开始往后；从后取值，index从-1开始往前
print (l[0]+ "----" + l[-1]);
# 集合尾部添加元素
l.append("hyman");
# 将后面集合的元素添加到前面集合，注意和append的区别，append是将append的整体作为一个元素纳入前
l += list(range(3));
# 集合指定位置插入元素
l.insert(1,"yang");
# 按照索引删除元素，无参数时从最后一位删除
l.pop();
l.pop(0);
# 删除首个符合条件的元素，不是索引
l.remove(123);
# 直接对集合元素进行赋值
l[0] ="hymanhu123";
print ("list:%s,length:%s"%(l,len(l)));
#tuple：元祖，小括号定义，也是有序的集合，但是一旦初始化后就不能修改；
# ==== tuple ====
t = tuple(range(10));
#t=("aads",123,true,None,12.3);
#定义只有一个元素的元祖，元素后追加“,”，以免误解成数学计算意义上的括号
t = ("cdsa",);
# 集合作为元祖的元素，我们可以修改集合的元素
t = ("vsv", ["aaa", "sss"]);
t[1][1] = "bbbb";
print("tuple: %s, length: %s"%(t, len(t)));

#dict：全称 Dictionary，使用 Key-Value 存储，具有极快的查询速度（list 逐个查找，dict 索引查找），Key 必须是不可变对象
# ==== dict ====
d = {"name":"hyman","age":33,"money":22.3};
print ("dict:%s,length:%s"%(d,len(d)));
# get 取值，没有返回 None，也可给定默认值
print(d.get("name"), d.get("name1"), d.get("name1", "hujiang"));
# 赋值取值
d["aaaa"] = "aaaa";
d["name"] = "yhq1";
print (d["name"],d["aaaa"]);
# 删除
d.pop("money");
print ("dict:%s,length:%s"%(d,len(d)));
# 合并dict
dict_1={"name":"yhq","age":22};
dict_2={"sex":"man"};
print (dict(dict_1,**dict_2));

#存储的是一组 Key 集合，不存储 Value，没有重复元素，无序，自动过滤重复 Key，而且 Key 也必须为不可变对象；
# ==== set ====
s = set(["aaa",123,123,True]);
s.add("fdsaa");
# 删除首个符合条件的元素
s.remove(123);
# 删除第一个元素，无参
s.pop();
print("set: %s, length: %s"%(s, len(s)));
# 交集、合集
s2 = set([123, "fdcasc"]);
print(s & s2);
print(s | s2);